﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace KingerRobot.MexicoSailunMDC.SpiService;

public class EmsPickImpl : IEmsPickService
{
    private static readonly object lockobject = new object();

    //public int CreateTask(int taskNo, long locId)
    //{
    //    var manager = new TaskManager();
    //    var taskAndCmd = manager.GetTaskAndCmdByTaskNo(taskNo);
    //    if (taskAndCmd == null)
    //    {
    //        WriteLog($"Ems抓取位未找到任务号为{taskNo}的任务或指令");
    //        return -1;
    //    }

    //    if (taskNo > 0)
    //    {
    //        WriteLog($"EMS取货位{locId}，读取到任务号：{taskNo}的任务或指令", true);
    //    }

    //    var ditch = taskAndCmd?.Task?.CuringDitch ?? 0;

    //    var excutableCount = manager.GetDitchExcutableEmsTaskCount(ditch);

    //    if (excutableCount >= 2)
    //    {
    //        WriteLog($"第{ditch}排已经有{excutableCount}个可执行任务，暂时不生成新EMS任务，请查看是否有手动拿胎但未删除任务的行为", true);

    //        return -2;
    //    }

    //    if (taskAndCmd.TaskCmd.StartLoc == locId)
    //    {
    //        WriteLog($"Ems抓取位任务号{taskNo}已经存在开始位置为{locId}的指令", true);
    //        return taskAndCmd.TaskCmd.TaskNo.Value;
    //    }

    //    if (locId != taskAndCmd.TaskCmd.TargetLoc && locId != taskAndCmd.TaskCmd.StartLoc)
    //    {
    //        var oldTaskNo = taskAndCmd.Task.TaskNo;
    //        XLogHelper.LogToDb($"任务{oldTaskNo}在ems抓取位错胎。预期到达{taskAndCmd.TaskCmd.TargetLoc}，实际到达{locId}", WcsLogMsgLevel.Warning, "ems抓取位", taskAndCmd.Task.SkuCode, taskAndCmd.Task.Id, taskAndCmd.Task.TaskNo);
    //        //送错胎
    //        taskAndCmd = manager.RedirectToAbnormalLoc(taskAndCmd, locId, $"ems抓取位送错胎：预期到达{taskAndCmd.TaskCmd.TargetLoc}，实际到达{locId}");
    //        var num1 = manager.SaveChanges();

    //        if (num1 <= 0)
    //        {
    //            WriteLog($"创建EMS任务,送错取胎位，下异常，失败：{num1}");

    //            return -3;
    //        }

    //        XLogHelper.LogToDb($"任务{oldTaskNo}在ems抓取位取消，新任务号为{taskAndCmd.Task.TaskNo}", WcsLogMsgLevel.Warning, "ems抓取位", taskAndCmd.Task.SkuCode, taskAndCmd.Task.Id, taskAndCmd.Task.TaskNo);
    //        return taskAndCmd.Task.TaskNo.Value;
    //    }

    //    manager.FinishTaskCmd(taskAndCmd, true);
    //    var taskCmd = manager.AddNewTaskCmdOfEmsPick(taskAndCmd, locId);
    //    taskAndCmd.TaskCmd = taskCmd;
    //    manager.UpdateTaskTypeAndStatusOfEmsPick(taskAndCmd);

    //    var num = manager.SaveChanges();

    //    if (num <= 0)
    //    {
    //        WriteLog($"创建EMS任务，失败：{num}");

    //        return -3;
    //    }

    //    XLogHelper.LogToDb($"任务{taskNo}添加EMS抓取指令", WcsLogMsgLevel.Info, "ems抓取位", taskAndCmd.Task.SkuCode, taskAndCmd.Task.Id, taskAndCmd.Task.TaskNo);
    //    return taskAndCmd.Task.TaskNo.Value;
    //}

    //public int GetExcutedTaskCmdCountByEquipId(long equipId1, long equipId2)
    //{
    //    var db = Db.Default;

    //    var result = db.WcsTaskCmds.Where(f => (f.EquipId == equipId1 || f.EquipId == equipId2) && f.CmdStatus == (int)EnumTaskStatus.Executed).Count();

    //    return result;
    //}

    ///// <summary>
    ///// 获取EMS下发信息
    /////     单车的运行逻辑【1-5受台，内车取（B），>6受台，外车取（A)】
    /////         1、单个位置有胎无组号（有组号，等待）
    /////         2、单个小车故障
    /////         3、没有组号（双无，一有一无）
    /////         4、两取货位，组号不一致，早创建的取消组号，先送单胎
    /////     双胎的运行逻辑
    /////         有组号且组号相同
    ///// </summary>
    ///// <param name="locId1"></param>
    ///// <param name="locId2"></param>
    ///// <param name="singleWorkableNo"></param>
    ///// <param name="ditchConfig"></param>
    ///// <returns></returns>
    //public EmsTaskBean GetTaskBean(long locId1, long locId2, int singleWorkableNo, DitchConfig ditchConfig)
    //{
    //    var manager = new TaskManager();
    //    var taskAndCmd1 = manager.GetTaskAndCmdByStartLocAndStatus(locId1, EnumTaskStatus.Executable);
    //    var taskAndCmd2 = manager.GetTaskAndCmdByStartLocAndStatus(locId2, EnumTaskStatus.Executable);

    //    var taskBean = new EmsTaskBean();
    //    WriteLog($"{taskAndCmd1?.Task?.TaskNo},{taskAndCmd2?.Task?.TaskNo},任务下发给{singleWorkableNo}号车", true);
    //    try
    //    {
    //        if (taskAndCmd1 == null && taskAndCmd2 == null)
    //        {
    //            taskBean.Error = "没有需要执行的任务";
    //            return taskBean;
    //        }
    //        else if (taskAndCmd1 != null && taskAndCmd2 == null)
    //        {
    //            var index = GetIndex(taskAndCmd1?.Task?.CuringOrder ?? 0, singleWorkableNo);

    //            // ems抓取位置1有任务
    //            manager.UpdateTaskBeanForSingleTask(taskBean, taskAndCmd1, ditchConfig, singleWorkableNo != 0 ? singleWorkableNo : index, EmsConfig.PickStation1);
    //            return taskBean;
    //        }
    //        else if (taskAndCmd1 == null && taskAndCmd2 != null)
    //        {
    //            var index = GetIndex(taskAndCmd2?.Task?.CuringOrder ?? 0, singleWorkableNo);

    //            // ems抓取位置2有任务
    //            manager.UpdateTaskBeanForSingleTask(taskBean, taskAndCmd2, ditchConfig, singleWorkableNo != 0 ? singleWorkableNo : index, EmsConfig.PickStation2);
    //            return taskBean;
    //        }
    //        else
    //        {
    //            //有小车故障，跑单车
    //            if (singleWorkableNo != 0)
    //            {
    //                return this.GetSingleWorkableTaskBean(taskBean, manager, taskAndCmd1, taskAndCmd2, singleWorkableNo, ditchConfig);
    //            }

    //            // ems抓取位置1和2都有任务，且组号相同
    //            if (this.IfCanExecuteDoubleTask(taskAndCmd1, taskAndCmd2))
    //            {
    //                manager.UpdateTaskBeanForDoubleTask(taskBean, taskAndCmd1, taskAndCmd2, ditchConfig);
    //                return taskBean;
    //            }

    //            // 2个任务都有分组并且组号不同的情况，将创建时间较早的组号解除，并将此任务改为下异常任务
    //            if (taskAndCmd1.Task.GroupNo.HasValue && taskAndCmd2.Task.GroupNo.HasValue && taskAndCmd1.Task.GroupNo != taskAndCmd2.Task.GroupNo)
    //            {
    //                string remark = $"2个取胎位组号不一致，分别为：{taskAndCmd1.Task.GroupNo},{taskAndCmd2.Task.GroupNo}";
    //                if (taskAndCmd1.Task.CreateTime < taskAndCmd2.Task.CreateTime)
    //                {
    //                    WriteLog($"开始解除组号：{taskAndCmd1.Task.GroupNo}。{remark}");
    //                    taskAndCmd1 = manager.RedirectToAbnormalLoc(taskAndCmd1, taskAndCmd1.Task.CurrentLoc.Value, remark, true);
    //                }
    //                else
    //                {
    //                    WriteLog($"开始解除组号：{taskAndCmd2.Task.GroupNo}。{remark}");
    //                    taskAndCmd2 = manager.RedirectToAbnormalLoc(taskAndCmd2, taskAndCmd2.Task.CurrentLoc.Value, remark, true);
    //                }
    //                manager.SaveChanges();

    //                return new EmsTaskBean
    //                {
    //                    CanExecute = false,
    //                    Error = $"组号不一致，分别为：{taskAndCmd1.Task.GroupNo},{taskAndCmd2.Task.GroupNo}，清除组号后重新下发任务",
    //                };
    //            }

    //            // 都没有组号时，按创建时间执行
    //            if (!taskAndCmd1.Task.GroupNo.HasValue && !taskAndCmd2.Task.GroupNo.HasValue)
    //            {
    //                if (taskAndCmd1.TaskCmd.CreateTime > taskAndCmd2.TaskCmd.CreateTime)
    //                {
    //                    var index = GetIndex(taskAndCmd2?.Task?.CuringOrder ?? 0, singleWorkableNo);

    //                    WriteLog($"都没有组号时，按创建时间执行任务{taskAndCmd2.Task.TaskNo}");
    //                    manager.UpdateTaskBeanForSingleTask(taskBean, taskAndCmd2, ditchConfig, index);
    //                }
    //                else
    //                {
    //                    var index = GetIndex(taskAndCmd1?.Task?.CuringOrder ?? 0, singleWorkableNo);

    //                    WriteLog($"都没有组号时，按创建时间执行任务{taskAndCmd1.Task.TaskNo}");
    //                    manager.UpdateTaskBeanForSingleTask(taskBean, taskAndCmd1, ditchConfig, index);
    //                }
    //                return taskBean;
    //            }

    //            // 否则先执行无组号的任务
    //            if (!taskAndCmd1.Task.GroupNo.HasValue)
    //            {
    //                var index = GetIndex(taskAndCmd1?.Task?.CuringOrder ?? 0, singleWorkableNo);

    //                //异常情况下，直接根据取胎位找对应小车 || 小车故障时，根据另一个车下发
    //                if (taskAndCmd1.Task.TaskType == (int)EnumTaskType.Abnormal && singleWorkableNo == 0)
    //                {
    //                    index = 1;
    //                }

    //                WriteLog($"执行无组号的任务{taskAndCmd1.Task.TaskNo}，index为：{index}", true);
    //                manager.UpdateTaskBeanForSingleTask(taskBean, taskAndCmd1, ditchConfig, index);
    //                return taskBean;
    //            }
    //            else
    //            {
    //                var index = GetIndex(taskAndCmd2?.Task?.CuringOrder ?? 0, singleWorkableNo);

    //                //异常情况下，直接根据取胎位找对应小车 || 小车故障时，根据另一个车下发
    //                if (taskAndCmd2.Task.TaskType == (int)EnumTaskType.Abnormal && singleWorkableNo == 0)
    //                {
    //                    index = 2;
    //                }

    //                WriteLog($"执行无组号的任务{taskAndCmd2.Task.TaskNo}，index为：{index}", true);
    //                manager.UpdateTaskBeanForSingleTask(taskBean, taskAndCmd2, ditchConfig, index);
    //                return taskBean;
    //            }
    //        }
    //    }
    //    catch (Exception ex)
    //    {
    //        WriteLog(ex.ToString(), true);
    //        return EmsTaskBean.Create(ex.Message);
    //    }
    //}

    //private int GetIndex(int curingOrder, int singleWorkableNo)
    //{
    //    if (singleWorkableNo > 0)
    //    {
    //        return singleWorkableNo;
    //    }

    //    //默认是外部小车（线体末梢）
    //    var index = 1;

    //    //1-6受台，内部小车送
    //    if (curingOrder <= 6)
    //    {
    //        index = 2;
    //    }

    //    return index;
    //}

    //private EmsTaskBean GetSingleWorkableTaskBean(EmsTaskBean taskBean, TaskManager manager, TaskAndCmd taskAndCmd1, TaskAndCmd taskAndCmd2, int singleWorkableNo, DitchConfig ditchConfig)
    //{
    //    TaskAndCmd taskAndCmd = null;
    //    int pickStation = 0;
    //    if (taskAndCmd1.TaskCmd.CreateTime > taskAndCmd2.TaskCmd.CreateTime)
    //    {
    //        taskAndCmd = taskAndCmd2;
    //        pickStation = EmsConfig.PickStation2;
    //    }
    //    else
    //    {
    //        taskAndCmd = taskAndCmd1;
    //        pickStation = EmsConfig.PickStation1;
    //    }

    //    WriteLog($"EMS{singleWorkableNo}号车单车运行，按创建时间执行任务{taskAndCmd.Task.TaskNo}，取胎台号：{pickStation}");

    //    if (taskAndCmd.Task.GroupNo.HasValue)
    //    {
    //        manager.ClearGroupNo(taskAndCmd, $"EMS{singleWorkableNo}号车单车运行，双车任务修改为单车任务");
    //        manager.SaveChanges();
    //    }
    //    WriteLog($"执行有故障的任务{taskAndCmd.Task.TaskNo}，可用小车：{singleWorkableNo}", true);
    //    manager.UpdateTaskBeanForSingleTask(taskBean, taskAndCmd, ditchConfig, singleWorkableNo, pickStation);
    //    return taskBean;
    //}

    //private bool IfCanExecuteDoubleTask(TaskAndCmd taskAndCmd1, TaskAndCmd taskAndCmd2)
    //{
    //    //if (taskAndCmd1.Task.IsAbnormal.Value == true && taskAndCmd2.Task.IsAbnormal.Value == true) //都是异常任务，
    //    //{
    //    //    if (!PathHelper.CheckIfTaskPathInvalid(taskAndCmd1, 1, out _) && !PathHelper.CheckIfTaskPathInvalid(taskAndCmd2, 2, out _)) //并且路径正确，允许同时执行
    //    //    {
    //    //        return true;
    //    //    }
    //    //}

    //    if (taskAndCmd1.Task.GroupNo.HasValue && taskAndCmd1.Task.GroupNo == taskAndCmd2.Task.GroupNo) //正常任务是同一组
    //    {
    //        return true;
    //    }
    //    return false;
    //}

    //public int ExecuteTask(int taskANo, int taskBNo, long equipAId, long equipBId)
    //{
    //    var manager = new TaskManager();
    //    TaskAndCmd taskAndCmdA = null;
    //    TaskAndCmd taskAndCmdB = null;

    //    //List<EndParam> endPrams = new();
    //    if (taskANo != 0)
    //    {
    //        taskAndCmdA = manager.GetTaskAndCmdByTaskNo(taskANo);

    //        //if (taskAndCmdA is not null)
    //        //{
    //        //    manager.CreateEndParams(ref endPrams, taskAndCmdA?.Task?.TrackId, "E");
    //        //}
    //    }
    //    if (taskBNo != 0)
    //    {
    //        taskAndCmdB = manager.GetTaskAndCmdByTaskNo(taskBNo);

    //        //if (taskAndCmdB is not null)
    //        //{
    //        //    manager.CreateEndParams(ref endPrams, taskAndCmdB?.Task?.TrackId, "E");
    //        //}
    //    }


    //    //if (!endPrams.Any() && ((taskAndCmdA is not null && (taskAndCmdA?.Task?.IsAbnormal ?? false) == false) || (taskAndCmdB is not null && (taskAndCmdB?.Task?.IsAbnormal ?? false) == false)))
    //    //{
    //    //    WriteLog($"EMS放胎完成-回写Mes胎号参数列表为空，{endPrams.ToJson()}");

    //    //    return 0;
    //    //}

    //    //var mesService = RpcHelper.Create<IMesService>();

    //    //if (endPrams.Any())
    //    //{
    //    //    var res = mesService.AddOutEnds(endPrams);

    //    //    if (res <= 0)
    //    //    {
    //    //        WriteLog($"EMS放胎完成-回写Mes胎号失败，结果：{res}");

    //    //        return 0;
    //    //    }
    //    //}


    //    if (taskANo != 0)
    //    {
    //        if (taskAndCmdA == null)
    //        {
    //            WriteLog($"Ems抓取位未找到任务A号为{taskANo}的任务或指令", true);
    //            return -1;
    //        }
    //        manager.UpdateEmsExcuteTime(taskAndCmdA?.Task?.TrackId ?? 0);
    //        manager.ExecuteTaskAndCmd(taskAndCmdA, equipAId);
    //    }
    //    if (taskBNo != 0)
    //    {
    //        if (taskAndCmdB == null)
    //        {
    //            WriteLog($"Ems抓取位未找到任务B号为{taskBNo}的任务或指令", true);
    //            return -1;
    //        }

    //        manager.UpdateEmsExcuteTime(taskAndCmdB?.Task?.TrackId ?? 0);
    //        manager.ExecuteTaskAndCmd(taskAndCmdB, equipBId);
    //    }

    //    manager.SaveChanges();

    //    if (taskAndCmdA != null)
    //    {
    //        XLogHelper.LogToDb($"任务{taskAndCmdA.Task.TaskNo}EMS抓取指令已执行", WcsLogMsgLevel.Info, "ems抓取位", taskAndCmdA.Task.SkuCode, taskAndCmdA.Task.Id, taskAndCmdA.Task.TaskNo);
    //    }
    //    if (taskAndCmdB != null)
    //    {
    //        XLogHelper.LogToDb($"任务{taskAndCmdB.Task.TaskNo}EMS抓取指令已执行", WcsLogMsgLevel.Info, "ems抓取位", taskAndCmdB.Task.SkuCode, taskAndCmdB.Task.Id, taskAndCmdB.Task.TaskNo);
    //    }
    //    return 1;
    //}

    //public int FinishTask(int taskANo, int taskBNo)
    //{
    //    var manager = new TaskManager();
    //    TaskAndCmd taskAndCmdA = null;
    //    TaskAndCmd taskAndCmdB = null;

    //    List<EndParam> endPrams = new();
    //    if (taskANo != 0)
    //    {
    //        taskAndCmdA = manager.GetTaskAndCmdByTaskNo(taskANo);

    //        if (taskAndCmdA is not null)
    //        {
    //            manager.CreateEndParams(ref endPrams, taskAndCmdA?.Task?.TrackId, "E");
    //        }
    //    }
    //    if (taskBNo != 0)
    //    {
    //        taskAndCmdB = manager.GetTaskAndCmdByTaskNo(taskBNo);

    //        if (taskAndCmdB is not null)
    //        {
    //            manager.CreateEndParams(ref endPrams, taskAndCmdB?.Task?.TrackId, "E");
    //        }
    //    }

    //    if (taskAndCmdA is null && taskAndCmdB is null)
    //    {

    //        WriteLog($"两车反馈任务都不存在");

    //        return -10;
    //    }

    //    if (!endPrams.Any() && ((taskAndCmdA is not null && (taskAndCmdA?.Task?.IsAbnormal ?? false) == false) || (taskAndCmdB is not null && (taskAndCmdB?.Task?.IsAbnormal ?? false) == false)))
    //    {
    //        WriteLog($"EMS放胎完成-回写Mes胎号参数列表为空，{endPrams.ToJson()}");

    //        return 0;
    //    }

    //    var mesService = RpcHelper.Create<IMesService>();

    //    if (endPrams.Any())
    //    {
    //        var res = mesService.AddOutEnds(endPrams);

    //        if (res <= 0)
    //        {
    //            WriteLog($"EMS放胎完成-回写Mes胎号失败，结果：{res}");

    //            return 0;
    //        }
    //    }

    //    if (taskAndCmdA != null)
    //    {
    //        manager.FinishTask(taskAndCmdA.Task, $"正常完成任务");
    //    }
    //    if (taskAndCmdB != null)
    //    {
    //        manager.FinishTask(taskAndCmdB.Task, $"正常完成任务");
    //    }

    //    if (taskAndCmdA != null && taskAndCmdB != null && taskAndCmdA.Task.MasterId == taskAndCmdB.Task.MasterId)
    //    {
    //        manager.BakAndDeleteMaster(taskAndCmdA.Task.MasterId.GetValueOrDefault());
    //    }

    //    return manager.SaveChanges();
    //}

    public void FlushCuringScadaStatus()
    {
        lock (lockobject)
        {
            var mesService = K8.RSF.Client.Create<IMesService>();

            var curingStatuss = mesService.GetTcmStatus();

            if (curingStatuss is null || !curingStatuss.Any())
            {
                WriteLog($"未找到硫化机存胎器等信息");
                return;
            }
            var db = Db.Default;

            foreach (var curingStatus in curingStatuss)
            {
                var curing = db.RcsEquipCurings.Where(f => f.CuringCode == curingStatus.TCM_NO && f.CuringDir == curingStatus.TCM_DIR).FirstOrDefault();

                var reqNum = curingStatuss.Where(t => t.TCM_NO == curingStatus.TCM_NO && t.GT_REQ == "Y").Count();

                var rcvFlag = "N";
                if (reqNum == 2)
                {
                    rcvFlag = "Y";
                }

                if (curing is null)
                {
                    continue;
                }

                var scadas = db.ScadaBoxs.Where(f => f.EquipId == curing.Id).ToList();

                if (scadas is null || !scadas.Any())
                {
                    continue;
                }

                var curingScada = scadas.Where(f => f.BoxType == (int)EnumScadaBoxType.ScadaCuring).FirstOrDefault();

                if (curingScada is not null)
                {
                    curingScada.BoxName = curingStatus.GT_REQ;
                    curingScada.TcmSpec = curingStatus.TCM_SPEC;
                    curingScada.TcmSpecDesc = curingStatus.TCM_SPEC_DESC;
                    curingScada.RcvFlag = rcvFlag;
                    curingScada.RegDt = curingStatus.REG_DT.GetValueOrDefault();
                }

                var receivePlatFormScada = scadas.Where(f => f.BoxType == (int)EnumScadaBoxType.ScadaReceivePlatForm).FirstOrDefault();

                if (receivePlatFormScada is not null)
                {
                    receivePlatFormScada.BoxName = curingStatus.CV_GT;
                    receivePlatFormScada.TcmSpec = curingStatus.TCM_SPEC;
                    receivePlatFormScada.TcmSpecDesc = curingStatus.TCM_SPEC_DESC;
                }

                var armScada = scadas.Where(f => f.BoxType == (int)EnumScadaBoxType.ScadaArm).FirstOrDefault();

                if (armScada is not null)
                {
                    armScada.BoxName = curingStatus.LD_GT;
                    armScada.TcmSpec = curingStatus.TCM_SPEC;
                    armScada.TcmSpecDesc = curingStatus.TCM_SPEC_DESC;
                }



                db.SaveChanges();
            }

        }
    }


}
